﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using HR60_PanelSoft.Model;
using HR60_PanelSoft.Model.BaseModel;
using HR60_PanelSoft.View.Base;
using HR60_PanelSoft.View.TabForms.ListItems;

namespace HR60_PanelSoft.View.TabForms
{
    //GC: [g1]保存面板编辑[PanelForm]@s1
    //GC: [g2]加载面板编辑[PanelForm]@s2
    //GC: [g3]开合类负载[PanelForm]@s1

    //GC: [g4]温控器类设备编辑[PanelForm]@sx

    //GC: [g5]空调分机4/5路可选[PanelForm]@sx
    //GC: [g6]约束规则
    //GC: [g7]面板索引，不可编辑[PanelForm]
    //GC: [g8]180711bug[PanelForm]

    //GC: [g9]解绑开合类设备，存在bug[PanelForm]
    //GC: [g10]解绑温控器类设备，存在bug[PanelForm]
    //GC: [g11]解绑485类设备，存在bug[PanelForm]
    //GC: [g12]485高级设备绑定，第一通道bug[PanelForm]
    //GC: [g13]名称修改不能反射到树[PanelForm]

    //GC: [g14]智能终端逻辑优化[PanelForm]
    //GC: [g15]联调7-21-3,温控器型空调4/5路选择问题[PanelForm]
    //GC: [g16]联调7-23-1：开合类设备取消关联bug[PanelForm]
    //GC: [g17]bug2182/2183/2184[PanelForm]
    //GC: [g18]bug2185/2186/2187[PanelForm]
    //GC: [g19]bug2192/2203/2204/2205[PanelForm]
    //GC: [g20]优化：4bug2191[PanelForm]
    //GC: [g21]bug2194[PanelForm]
    //GC: [g22]bug2955[PanelForm]
    //GC: [g23]bug2950[PanelForm]
    //GC: [g24]bug2957[PanelForm]
    //GC: [g25]bug2959[PanelForm]
    //GC: [g26]bug3014/3015[PanelForm]
	public partial class PanelForm : BaseForm
	{
        /* [g1.s1]提升panel到私有字段 */
        HR60_PanelSoft.Model.Panel _cur_panel = null;

        /* end of g1.s1 */

        /* [g3.s1] */

        /// <summary>
        /// 当前的PinItem数组
        /// </summary>
        List<PinItem> _CurPinItems = new List<PinItem>();
        /* end of [g3.s1] */


		public PanelForm()
		{
			InitializeComponent();

			// 初始化样式列表
			IDictionary styleMap = new Dictionary<string, UIStyle>();
			styleMap.Add("项目默认选项", UIStyle.NULL);
			styleMap.Add("清爽", UIStyle.QingShuang);
			styleMap.Add("奢华", UIStyle.SheHua);
			selStyle.bindData(styleMap);

			// 初始化E++列表
			IDictionary eMap = new Dictionary<string, EplusType>();
			eMap.Add("未定义", EplusType.NULL);
			eMap.Add("灯光窗帘", EplusType.LampWin);
			eMap.Add("中央空调", EplusType.CentralAircon);
			eMap.Add("中央供暖", EplusType.CentralHeating);
			eMap.Add("新风系统", EplusType.CentralNewWind);
			eMap.Add("背景音乐", EplusType.BGM);
			selEplus.bindData(eMap);

            /* [g5.s1]初始化选择状态 */
            this.RADIO_ONGBOX_4PIN.CheckedChanged += OnRadioCheckChanged;
            this.RADIO_ONGBOX_5PIN.CheckedChanged += OnRadioCheckChanged;
            this.RADIO_ONGBOX_4PIN.Tag = 4;
            this.RADIO_ONGBOX_5PIN.Tag = 5;
            this.RADIO_ONGBOX_4PIN.Checked = false;
            
            this.RADIO_ONGBOX_5PIN.Checked = true;
            /* [g15.s2] */
            //this.GBOX_ONMAINPNL_HOLD.Visible = false;
            this.GBOX_ONMAINPNL_HOLD.Visible = true;
            /* end of [g15.s2] */

            /* end of [g5.s1] */

            /* [g7.s2] 面板序号需要可编辑 */
            /* [g7.s1] 禁用面板序号选择 */
            
            //this.txtIndex.Enabled = false;
            /* end of [g7.s1] */

            this.txtIndex.Enabled = true;
            /* end of [g7.s2] */

		}


		// 绑定数据
		public override void refreshFormData(System.Collections.Generic.IDictionary<string, object> dataMap)
		{
			_cur_panel = (HR60_PanelSoft.Model.Panel)dataMap["panel"];

            txtName.Value = _cur_panel.name;
            txtIndex.Value = _cur_panel.index.ToString();
            selStyle.Value = _cur_panel.style;
            selEplus.Value = _cur_panel.eplusType;

            /* [g18.s1]网关编辑界面需要禁用E++和空调分机负载数 */
            GBOX_ONMAINPNL_HOLD.Enabled = true;
            selEplus.Enabled = true;
            if (_cur_panel.type.name == "网关")
            {
                GBOX_ONMAINPNL_HOLD.Enabled = false;
                selEplus.Enabled = false;
            }
            
            /* end of [g18.s1] */



            /* [g2.s3]选择selType */
            //selType.bindData((IList)panelTypes, "name");
            /* 
             * 此处，由于Value没有用，而且反射有问题，因此放弃对Value的绑定，
             * text和value都使用value
             */
            /* 重新加载 */
            List<SelectItem> list_si = new List<SelectItem>();
            foreach (PanelType pt in panelTypes)
            {
                SelectItem si = new SelectItem(pt.name, pt.name);
                if(null != si)
                    list_si.Add(si);
            }
            
            selType.fillItems(list_si);
            /*  */

            selType.Value = _cur_panel.type.name;
            
            /* end of [g2.s3] */


            /* g2.s2 加载负载对象 */
			
			cleanPinItem(); /* 加载前先清理控件 */

            /* 加载负载 */
            foreach (Pin pin in _cur_panel.loadPins)
			{
				appendPinItem(pin);
			}
            if (_cur_panel.type.hasM485Model)
			{
                appendPinItem(_cur_panel.m485Pin);
			}
            /* end of g2.s2 */

            /* [g24.s2] 如果是空调，则将负载数目反射到Radio */
            if (_cur_panel.type.name == "HK-60Q6CW" || _cur_panel.type.name == "HK-60P4CW")
            {

                int tempCnt = 0;
                foreach (PinItem pi in _CurPinItems)
                {
                    if (!pi.Enabled)
                        tempCnt++;
                }
                SetRadioWithoutEvt(tempCnt == 3); /* 需考虑第一通道Enable为true */
            }

            /* end of [g24.s2] */

		}

		// 数据修改事件
		public override void onFormChanged(BaseFormControl sender, System.EventArgs e)
		{

            /* [g17.s1] */
            ValueChangedEventArgs vcea = (ValueChangedEventArgs)e;

            /* end of [g17.s1] */

			//windowMain.doSavePanel((HR60_PanelSoft.Model.Panel)this.bindDataMap["panel"], this.getFields());
            if (!(sender is PinItem))
            {
                _cur_panel.name = (string)txtName.Value;
                if (!int.TryParse((string)txtIndex.Value, out _cur_panel.index))
                    //GCERR:
                    return;
                _cur_panel.style = (UIStyle)selStyle.Value;
                _cur_panel.eplusType = (EplusType)selEplus.Value;

                /* [g13.s1]映射名字到树 */
                windowMain.doSavePanel((string)txtName.Value);
                /* end of [g13.s1] */
            }

            /* [g3.s1]检查是否存在开合类设备，并进行控件刷新 */



            ///* [g17.s2] */
            //if (vcea.Type == EventType.GroupInPinItem)
            //    return;
            ///* end of [g17.s2] */

            ///* [g19.s1]选择selDev */
            //if (vcea.Type == EventType.DeviceInPinItem)
            //{
            //    //GCTODO:
            //    /* 判断温控器逻辑 */
                
            //}

            /* end of [g19.s1] */

            /* [g8.s1] 鲁棒需要优化，该处先以功能有限 */

            /* 鲁棒 */
            if (sender is PinItem)
            {
                PinItem pinitem = (PinItem)sender;
                IDictionary<string, object> id = (IDictionary<string, object>)pinitem.Value;

                if (id.Values.Count > 0)
                {
                    object o = new object();

                    if (!id.TryGetValue("device", out o))
                    {
                        return;
                    }
                    else if (null == o)   /* 两种情况：1. 初始化阶段；2. 设备组复位 */
                    {
                        /* [g9.s1] 修正辅通道的同步bug */

                        //bool isReset = false;
                        int tempMainIdx = _CurPinItems.IndexOf(pinitem);

                        if (pinitem.IsMainChannel)
                        {

                            //foreach (PinItem x in _CurPinItems)
                            //{
                            //    if (x.TagPin.isMainPin)
                            //    {
                            //        isReset = true;
                            //        break;
                            //    }
                            //}
                            //if (isReset)
                            //{
                            //    int idx = _CurPinItems.IndexOf(pinitem);
                            //    if (idx + 1 == _CurPinItems.Count)
                            //        return;
                            //    PinItem pi2 = _CurPinItems[idx + 1];
                            //    if (pi2.TagPin.isMainPin)
                            //        return;
                            //    pi2.SetPin(_cur_panel.loadPins[idx + 1], pi2.ChannelName);
                            //    pi2.TagPin.isMainPin = true;
                            //    pi2.Enabled = true;
                            //}

                            for (int i = tempMainIdx + 1; i < _CurPinItems.Count; i++)
                            {
                                if (_CurPinItems[i].TagPin.isMainPin) /**/
                                {
                                    break;
                                }
                                else  /* 如果后面都是辅通道，则全部恢复 */
                                {
                                    /* [g16.s1]清理掉辅通道 */
                                    if (_CurPinItems[i].TagPin.connectedDevice != null)
                                    {
                                        Device tempD = _CurPinItems[i].TagPin.getConnectedDevice();
                                        if (!tempD.connectedPins.Remove(_CurPinItems[i].TagPin.uuid))
                                        {
                                            //GCERR:
                                            return;
                                        }
                                        _CurPinItems[i].TagPin.connectedDevice = null;
                                    }
                                    //_CurPinItems[i].TagPin.connectedDevice = null;

                                    /* end of [g16.s1]  */
                                    _CurPinItems[i].TagPin.isMainPin = true;
                                    _CurPinItems[i].SetPin(_cur_panel.loadPins[i], _CurPinItems[i].ChannelName);
                                    _CurPinItems[i].Enabled = true;
                                }
                            }


                        }
                        /*[g11.s1]*/
                        else
                        {
                            //_CurPinItems[tempMainIdx].TagPin.connectedDevice = null;
                            //_CurPinItems[tempMainIdx].TagPin.isMainPin = true;
                            //_CurPinItems[tempMainIdx].SetPin(
                            //    _CurPinItems[tempMainIdx].TagPin.type == PinType.M485? (Pin)_cur_panel.m485Pin:
                            //    _cur_panel.loadPins[tempMainIdx], _CurPinItems[tempMainIdx].ChannelName);
                            //_CurPinItems[tempMainIdx].Enabled = true;


                        }
                        /* end of [g11.s1] */
                        return;
                        /* end of [g9.s1] */
                    }
                    else
                    {
                        /* [g25.s1]#bug2959,当为温控器，做辅通道检查 */
                        if (pinitem.isFirstChannel && (vcea.Type == EventType.DeviceInPinItem))
                        {
                            /* 获取selDevice的设备类型 */
                            Device tempDev = (Device)o;
                            /* 如果不是中央空调或者新风系统，则将所有辅通道恢复 */
                            if ((tempDev.type.exType != ExDeviceType.CentralAircon)
                                && (tempDev.type.exType != ExDeviceType.CentralNewWind))
                            {
                                int i = 1;
                                /* [g26.s1]此处有鲁棒性陷阱 */

                                //while (!_CurPinItems[i].TagPin.isMainPin)
                                while ((_CurPinItems.Count > i) && (!_CurPinItems[i].TagPin.isMainPin))
                                /* end of [g26.s1]  */
                               {
                                    _CurPinItems[i].TagPin.connectedDevice = null;
                                    _CurPinItems[i].TagPin.isMainPin = true;
                                    _CurPinItems[i].SetPin(_cur_panel.loadPins[i], _CurPinItems[i].ChannelName);
                                    _CurPinItems[i].Enabled = true;
                                    i++;

                                }

                            }
                            /* 满足条件则清理 */
                        }

                        /* end of [g25.s1] */
                    }
                }
                else
                    return;



                /* [g4.s1]判断首通道是否选中温控器类设备 */


                //PinItem pinitem = (PinItem)sender;

                if (pinitem.TagPin.connectedDevice != null)
                {
                    Device p = null;
                    Device d = null;
                    findDeviceByUuid(pinitem.TagPin.connectedDevice, ref p, ref d);
                    //if ((pinitem.TagPin.getConnectedDevice().type.protocolTag == null)) /* 取巧方法，分机为null */
                    if (p != null && d != null) /* 分机 */
                    {

                        /* 需要判断面板是否能支持高级设备 */
                        /*
                         * 1. 只有4L + 1T以上可以配置空调，如Q6、P6
                         * 2. 只有4L 以上可以配置新风，如Q6、P4、P6
                         * 3. 只有
                         */

                        /*  */

                        /* [g20.s1] */
                        //if (vcea.Type != EventType.SubInPinItem) /* 如果不是分机选择，则返回 */
                        //    return;
                        /* end of [g20.s1] */

                        if (pinitem.isFirstChannel)
                        {
                            /* 判断面板 */

                            /* 绑定负载 */
                            switch (p.type.exType)
                            {
                                case ExDeviceType.CentralAircon:
                                    /* [g15.s1]负载选择显示方式优化 */
                                    //this.GBOX_ONMAINPNL_HOLD.Visible = true;
                                    /* end of [g15.s1] */
                                    /* [g22.s1]bug2955 */
                                    /* 判断负载路数,判断负载类型 */
                                    int tempPnlCnt = _cur_panel.loadPins.Count;
                                    if (tempPnlCnt > 4)
                                        tempPnlCnt = 5;
                                    //for (int i = 0; i < 5; i++)
                                    for (int i = 0; i < tempPnlCnt; i++)
                                    /* end of [g22.s1] */

                                    {
                                        if (i == 0)
                                            /* [g20.s2] */
                                            //_CurPinItems[i].SetPin(pinitem.TagPin, _CurPinItems[i].ChannelName);
                                            _CurPinItems[i].SetSub(pinitem.TagPin);
                                            /* end of [g20.s2] */
                                        else
                                        {
                                            _CurPinItems[i].SetAssisPin(pinitem.TagPin, _CurPinItems[i].ChannelName);
                                            _CurPinItems[i].Enabled = false;
                                        }
                                    }
                                    return;
                                case ExDeviceType.CentralNewWind:
                                    /* [g22.s2]bug2955 */
                                    //for (int i = 0; i < 4; i++)
                                    for (int i = 0; i < 4; i++) 
                                    /* end of [g22.s2] */
                                    {
                                        if (i == 0)
                                            /* [g20.s3] */
                                            //_CurPinItems[i].SetPin(pinitem.TagPin, _CurPinItems[i].ChannelName);
                                            _CurPinItems[i].SetSub(pinitem.TagPin);
                                            /* end of [g20.s3] */
                                        else
                                        {
                                            _CurPinItems[i].SetAssisPin(pinitem.TagPin, _CurPinItems[i].ChannelName);
                                            _CurPinItems[i].Enabled = false;
                                        }
                                    }
                                    return;
                                default:
                                    break;
                            }
                        }
                        else
                        {
                            if (p.type.group == "温控器类") /* 带分机的温控器类设备 */
                            {
                                /* [g4.s3] */
                                ////if (d.type.exType == ExDeviceType.CentralAircon || d.type.exType == ExDeviceType.CentralNewWind)
                                //if (p.type.exType == ExDeviceType.CentralAircon || p.type.exType == ExDeviceType.CentralNewWind)
                                //{

                                //    /*  */
                                //    ViewUtils.showAlert(d.nickName + "必须挂在第一个负载上！");
                                //    pinitem.SetPin(_cur_panel.loadPins[pinitem.TagPin.index], pinitem.ChannelName);
                                //    return;
                                //}


                            }
                            else if (p.type.group == "485类") /* 带分机的485类设备*/
                            {
                                if (!_cur_panel.type.hasM485Model)
                                {
                                    //GCERR:
                                    return;
                                }

                                
                                pinitem.SetPin(_cur_panel.m485Pin, pinitem.ChannelName);

                            }
                        }

                        /* [g19.s2]温控器供暖，每个面板只能有一个分机 */

                        if (p.type.exType == ExDeviceType.CentralHeating && vcea.Type == EventType.SubInPinItem)
                        {
                            
                            /* [g21.s1]将逻辑检查转移到PinItem */
                            /* 先检查是否关联多于一个负载 */

                            //for (int i = 0; i < _CurPinItems.Count; i++)
                            //{
                            //    PinItem pi = _CurPinItems[i];
                            //    if (pi.TagPin.connectedDevice != null)
                            //    {
                            //        Device tempSub = pi.TagPin.getConnectedDevice();
                            //        if (tempSub.type.name == "中央供暖系统分机-温控器型" &&
                            //            i != pinitem.TagPin.index)
                            //        {
                            //            /* 如果已经存在一个温控器系统分机，则取消此次关联 */

                            //            pinitem.TagPin.connectedDevice = null;
                            //            pinitem.TagPin.isMainPin = true;
                            //            pinitem.SetPin(_cur_panel.loadPins[pinitem.TagPin.index], pinitem.ChannelName);
                            //            pinitem.Enabled = true;
                            //            /* 清理设备中的pin */
                            //            tempSub.connectedPins.Remove(pinitem.TagPin.uuid);
                            //            /* 提示 */
                            //            View.ViewUtils.showAlert("一个面板中只能挂载一个温控器型中央供暖系统分机！\r\n");
                            //            return;
                            //        }
                            //    }
                            //}
                            /* end of [g21.s1] */

                            /* [g20.s4]消除无限递归 */
                            pinitem.SetSub(_cur_panel.loadPins[pinitem.TagPin.index]);
                            /* end of [g20.s4] */

                        }

                        /* end of [g19.s2] */
                    }
                    else if (p != null && d == null) /*所有负载类设备*/
                    {
                        if (p.type.group == "负载类") /* 只处理负载类 */
                        {
                            /* 处理开合类 */
                            if (pinitem.IsMainChannel) /* 主通道 */
                            {

                                /* [g10.s2] 如果主通道改变，先清理辅通道 */
                                int tempMainIdx = _CurPinItems.IndexOf(pinitem);

                                /* [g17.s3]效率起见，在此处理开合类的运行时间 */
                                if (vcea.Type == EventType.TimeInPinItem && pinitem.selTime.Visible
                                    && SwitchType.OPEN_JOIN == p.type.switchTypes[0])
                                {
                                    //((LoadPin)pinitem.TagPin).time = (int)pinitem.selTime.Value;
                                    /* 在此刷新辅通道时间 */
                                    int tempN = 0;

                                    int.TryParse(pinitem.selTime.Text, out tempN);
                                    ((LoadPin)_CurPinItems[tempMainIdx + 1].TagPin).time = tempN;
                                    return;
                                }
                                /* end of [g17.s3] */


                                for (int i = tempMainIdx + 1; i < _CurPinItems.Count; i++)
                                {
                                    if (_CurPinItems[i].TagPin.isMainPin)
                                    {
                                        break;
                                    }
                                    else
                                    {
                                        _CurPinItems[i].TagPin.connectedDevice = null;
                                        _CurPinItems[i].TagPin.isMainPin = true;
                                        _CurPinItems[i].SetPin(_cur_panel.loadPins[i], _CurPinItems[i].ChannelName);
                                        _CurPinItems[i].Enabled = true;
                                    }
                                }
                                /* end of [g10.s2] */



                                if (SwitchType.OPEN_JOIN == p.type.switchTypes[0])
                                {
                                    /* 主通道 */
                                    pinitem.SetPin(_cur_panel.loadPins[pinitem.TagPin.index], pinitem.ChannelName);

                                    /* 辅通道 */
                                    _CurPinItems[pinitem.TagPin.index + 1].SetAssisPin(pinitem.TagPin,
                                        _CurPinItems[pinitem.TagPin.index + 1].ChannelName);
                                    _CurPinItems[pinitem.TagPin.index + 1].Enabled = false;
                                    _CurPinItems[pinitem.TagPin.index + 1].TagPin.isMainPin = false;
                                }
                                /* [g10.s1] 优化 */
                                //else if (!_CurPinItems[pinitem.TagPin.index + 1].TagPin.isMainPin)
                                //{
                                //    /* 主通道 */
                                //    pinitem.SetPin(_cur_panel.loadPins[pinitem.TagPin.index], pinitem.ChannelName);

                                //    /* 辅通道 */
                                //    _cur_panel.loadPins[pinitem.TagPin.index + 1].connectedDevice = null;
                                //    _CurPinItems[pinitem.TagPin.index + 1].SetPin(_cur_panel.loadPins[pinitem.TagPin.index + 1],
                                //        _CurPinItems[pinitem.TagPin.index + 1].ChannelName);
                                //    _CurPinItems[pinitem.TagPin.index + 1].Enabled = true;
                                //    _CurPinItems[pinitem.TagPin.index + 1].TagPin.isMainPin = true;
                                //}
                                /* end of [g10.s1] */
                                else /* 非开合类 */
                                {
                                    pinitem.SetPin(_cur_panel.loadPins[pinitem.TagPin.index], pinitem.ChannelName);

                                }




                            }
                            else /* 辅通道 */
                            {
                                if (pinitem.TagPin.isMainPin)
                                {
                                    pinitem.SetPin(_cur_panel.loadPins[pinitem.TagPin.index], pinitem.ChannelName);
                                }
                            }


                        }
                        else if (p.type.group == "485类") /* 不带分机的485类设备*/
                        {
                            if (!_cur_panel.type.hasM485Model)
                            {
                                //GCERR:
                                return;
                            }

                            /* [g14.s1] 检查智能终端（灯光窗帘）*/
                            //if (p.type.name == "智能终端（灯光窗帘）")
                            //{
                            //    /* 检测Q6面板 */
                            //    bool tempHasQ6 = true;
                            //    foreach (Net n in proj.nets)
                            //    {
                            //        tempHasQ6 = false;
                            //        foreach (HR60_PanelSoft.Model.Panel pnl in n.panels)
                            //        {
                            //            if (pnl.type.name == "HK-60Q6CW" || pnl.type.name == "HK-50Q6CW")
                            //            {
                            //                tempHasQ6 = true;
                            //                break;
                            //            }
                            //        }
                            //        if (!tempHasQ6)
                            //        {
                            //            View.ViewUtils.showAlert("在绑定智能终端（灯光窗帘）设备之前，" +
                            //                "必须确保每个子网包含一个Q6面板！创建设备失败！");
                            //            return;
                            //        }
                            //    }

                            //}
                            //else if (p.type.name == "智能终端（全部功能）")
                            //{
 
                            //}

                            /* end of [g14.s1] */
                            pinitem.SetPin(_cur_panel.m485Pin, pinitem.ChannelName);
                        }
                    }


                }

                /* end of [g4.s1] */
            }

            /* end of [g8.s1] */

            /* 创新 */
            /* [g3.s3] 开合类设备 */
            //int tempPinIdx = -1;
            //PinItem tempMainPinItem = null;

            //foreach (PinItem pi in _CurPinItems)
            //{
            //    if (pi.TagPin is M485Pin)
            //        continue;

            //    if (pi.TagPin.index == tempPinIdx + 1 && tempPinIdx != -1)
            //    {
            //        //pi.SetPin(tempMainPinItem.TagPin, pi.ChannelName);
            //        //pi.TagPin.isMainPin = false;
            //        pi.SetAssisPin(pi.TagPin, pi.ChannelName);
            //        pi.Enabled = false;

            //        tempPinIdx = -1;
            //        tempMainPinItem = null;
            //        break;
            //    }

            //    if (null == pi.TagPin.getConnectedDevice())
            //        continue;
            //    if (pi.IsMainChannel)
            //    {
            //        if (SwitchType.OPEN_JOIN == pi.TagPin.getConnectedDevice().type.switchTypes[0])
            //        {
            //            tempPinIdx = pi.TagPin.index;
            //            tempMainPinItem = pi;
            //        }
            //        else
            //        {
            //            int idx = _CurPinItems.IndexOf(pi);
            //            if (idx + 1 == _CurPinItems.Count)
            //                return;
            //            PinItem pii = _CurPinItems[idx + 1];
            //            if (!pii.TagPin.isMainPin)
            //            {
            //                pii.SetPin(_cur_panel.loadPins[idx + 1], pii.ChannelName);
            //                pii.TagPin.isMainPin = true;
            //                pii.Enabled = true;
            //            }
            //            tempPinIdx = -1;
            //            tempMainPinItem = null;
            //        }
            //    }

            //}
            /* end of [g3.s3] */

            /* [g3.s4]优化开合类设备 */
            

            /*  */
            /* end of [g3.s1] */

            
		}

        /* [g5.s2] 按钮选择框事件 */
        public void OnRadioCheckChanged(object sender, EventArgs e)
        {
            RadioButton rb = (RadioButton)sender;
            if (!rb.Checked)
                return;
            int num = (int)rb.Tag;
            
            /* [g23.s1]先判断面板是否为4通道 */
            if (_cur_panel == null) return;
            if (_cur_panel.loadPins.Count == 4  && num == 5)
            {
                View.ViewUtils.showAlert("此面板只支持4路负载！");
                rb.Checked = false;
                return;
            }

            /* end of [g23.s1] */
            if (_CurPinItems.Count < 1)
                return;

            /* [g15.s4] 不再进行visible控制，而是使用RadioButton选择前判断 */
            if (_CurPinItems[0].TagPin.connectedDevice == null)
                return;
            Device dev0 = _CurPinItems[0].TagPin.getConnectedDevice();
            if (dev0.type.name != "中央空调系统分机-温控器型")
            {
                View.ViewUtils.showAlert("当前第一通道未绑定温控器型空调设备，不能进行负载数选择！");
                return;
            }
            /* end of [g15.s4] */
            _CurPinItems[4].Enabled = num == 4;
            if (num == 4)
            {
                /* [g5.s3] 当为4路时，第四通道有bug*/
                Device d = _cur_panel.loadPins[4].getConnectedDevice();
                if (d == null)
                {
                    //GCERR:
                    return;
                }
                if (!d.connectedPins.Exists(x => x == _cur_panel.loadPins[4].uuid))
                {
                    //GCERR:
                    return;
                }
                d.connectedPins.Remove(_cur_panel.loadPins[4].uuid);

                _cur_panel.loadPins[4].connectedDevice = null;
                _CurPinItems[4].TagPin.isMainPin = true;
                
                /* end of [g5.s3] */
                _CurPinItems[4].SetPin(_cur_panel.loadPins[4], _CurPinItems[4].ChannelName);
            }
            else
            {
                _CurPinItems[4].SetAssisPin(_cur_panel.loadPins[0], _CurPinItems[4].ChannelName);
            }
            //_CurPinItems[0].TagPin.getConnectedDevice().Tag = num;
            dev0.Tag = num;
        }

        /* end of [g5.s2] */

        /* [g24.s1]增加方法，用来切换Radio的显示，而不触发切换事件 */
        private void SetRadioWithoutEvt(bool check4Pin)
        {
            RADIO_ONGBOX_4PIN.CheckedChanged -= OnRadioCheckChanged;
            RADIO_ONGBOX_5PIN.CheckedChanged -= OnRadioCheckChanged;

            RADIO_ONGBOX_4PIN.Checked = check4Pin;
            RADIO_ONGBOX_5PIN.Checked = !check4Pin;

            RADIO_ONGBOX_4PIN.CheckedChanged += OnRadioCheckChanged;
            RADIO_ONGBOX_5PIN.CheckedChanged += OnRadioCheckChanged;
        }

        /* end of [g24.s1] */

		private void mapPin2Device(Device dev, LoadPin pin)
		{
			if (pin.type == PinType.M485) return;

			// 取消负载连接
			if (dev == null)
			{
			}

			// 查找可用的pin列表
			IList<LoadPin> list = new List<LoadPin>();
			bool findFlag = false;
			foreach (LoadPin mpin in ((HR60_PanelSoft.Model.Panel)this.bindDataMap["panel"]).loadPins)
			{
				if (mpin == pin)
				{
					findFlag = true;
					list.Add(mpin);
					continue;
				}
				if (findFlag && mpin.connectedDevice != null)
				{
					list.Add(mpin);
				}
			}

			// 判断pin是否够用
			if (dev.type.pinLen > list.Count)
			{
				throw new Exception("空闲的负载线路不足");
			}

		}


		#region Pin列表操作
        /*
         * g2.s1: pinItems的存在与架构冲突 ，优化之。
         * 
         */
		//IList<Control> pinItems = new List<Control>();

		private void appendPinItem(Pin pin)
		{

			PinItem pinItem = new PinItem(pin, pin.type == PinType.M485 ? "485" : ((LoadPin)pin).displayName);
            /* [g15.s3] */
            //pinItem.OnAirControlSelecetChanged += (AirControlEventArgs acea) =>
            //    {
            //        this.GBOX_ONMAINPNL_HOLD.Visible = acea.IsSeleceted;
            //    };
            /* end of [g15.s3] */
            /* [g4.s2] 修正不能刷新问题 */

            /* [g15.s5] 优化用户体验，当加载面板时，RadioButton会同步修改 */
            if (pinItem.isFirstChannel)
            {
                if (pinItem.TagPin.connectedDevice != null)
                {
                    Device tempDev = pinItem.TagPin.getConnectedDevice();

                    if (tempDev.Tag != null && tempDev.type.name == "中央空调系统分机-温控器型") /* 空调分机 */
                    {
                        int tempN = -1;
                        if (int.TryParse(tempDev.Tag.ToString(), out tempN))
                        {
                            this.RADIO_ONGBOX_5PIN.Checked = tempN == 5;
                        }
                    }
                }
            }
            /* end of [g15.s5] */

            pinItem.IsMainChannel = pinItem.TagPin.isMainPin;
            /*  */

			mainPanel.Controls.Add(pinItem);

            /* [g3.s3]   */
            _CurPinItems.Add(pinItem);
            /* end of [g3.s3] */
			//pinItems.Add(pinItem);
		}

		private void cleanPinItem()
		{
            //foreach (Control pinItem in pinItems)
            //{
            //    mainPanel.Controls.Remove(pinItem);
            //}
            List<int> idxs = new List<int>();
            foreach (Control c in mainPanel.Controls)
            {
                if (!(c is PinItem))
                    continue;
                idxs.Add(mainPanel.Controls.IndexOf(c));
            }

            /* 必须先降序 */
            idxs.Sort(); /* 默认升序 */
            idxs.Reverse(); /* 反序 */
            /* 逐个清除 */
            foreach (int i in idxs)
            {
                mainPanel.Controls.RemoveAt(i);
            }

            /* [g3.s4] 清理_PinItems */
            _CurPinItems.Clear();
            /* end of [g3.s4] */

		}

        /* end of g2.s1 */

		#endregion

        public bool is4Pin { get; set; }
    }
}
